home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 8: LINUX Games / Linux Cubed Series 8 - LINUX Games.iso / games / video / thrust-s.53 / thrust-s / thrust / src / graphics.c < prev    next >
C/C++ Source or Header  |  1995-10-15  |  13KB  |  591 lines
  1.  
  2. /* Written by Peter Ekberg, peda@lysator.liu.se */
  3.  
  4. #include <unistd.h>
  5. #include <stdio.h>
  6. #include "thrust.h"
  7.  
  8. void
  9. writeblock(word bx, word by, byte block)
  10. {
  11.   word tempx, tempy;
  12.  
  13.   *(bana+bx+by*lenx)=block;
  14.   tempx=bx;
  15.   tempy=by;
  16.   if(pblockx+BBILDX>lenx && tempx<BBILDX)
  17.     tempx+=lenx;
  18.   if(pblocky+BBILDY>leny && tempy<BBILDY)
  19.     tempy+=leny;
  20.   if(insideblock(tempx,tempy,pblockx,pblocky,0,0))
  21.     putblock(bblockx-pblockx+tempx, tempy%BBILDY,
  22.          blocks+(block<<6));
  23. }
  24.  
  25. #define NR_TP (6)
  26. #define SZ_TP (3)
  27. #define DIFF_TP (8)
  28.  
  29. void
  30. drawteleline(int round, int x1, int y1, int x2, int y2, int j, int k)
  31. {
  32.   int l;
  33.   static unsigned char telemem[2*5*4*NR_TP*SZ_TP];
  34.   static unsigned char *tm;
  35.  
  36.   switch(round) {
  37.   case 0:
  38.     tm=&telemem[0];
  39.     break;
  40.   case 1:
  41.     for(l=-2; l<=2; l++) {
  42.       *(graph_mem + (x1+(j+2)*DIFF_TP+k) + (y1+l)*PSCRX) = 65;
  43.       *(graph_mem + (x1-(j+2)*DIFF_TP-k) + (y1+l)*PSCRX) = 65;
  44.       *(graph_mem + (x1+l) + (y1+(j+2)*DIFF_TP+k)*PSCRX) = 65;
  45.       *(graph_mem + (x1+l) + (y1-(j+2)*DIFF_TP-k)*PSCRX) = 65;
  46.       *(graph_mem + (x2+(j+2)*DIFF_TP+k) + (y2+l)*PSCRX) = 65;
  47.       *(graph_mem + (x2-(j+2)*DIFF_TP-k) + (y2+l)*PSCRX) = 65;
  48.       *(graph_mem + (x2+l) + (y2+(j+2)*DIFF_TP+k)*PSCRX) = 65;
  49.       *(graph_mem + (x2+l) + (y2-(j+2)*DIFF_TP-k)*PSCRX) = 65;
  50.     }
  51.     break;
  52.   case 2:
  53.     for(l=-2; l<=2; l++) {
  54.       *(tm++) = *(graph_mem + (x1+(j+2)*DIFF_TP+k) + (y1+l)*PSCRX);
  55.       *(tm++) = *(graph_mem + (x1-(j+2)*DIFF_TP-k) + (y1+l)*PSCRX);
  56.       *(tm++) = *(graph_mem + (x1+l) + (y1+(j+2)*DIFF_TP+k)*PSCRX);
  57.       *(tm++) = *(graph_mem + (x1+l) + (y1-(j+2)*DIFF_TP-k)*PSCRX);
  58.       *(tm++) = *(graph_mem + (x2+(j+2)*DIFF_TP+k) + (y2+l)*PSCRX);
  59.       *(tm++) = *(graph_mem + (x2-(j+2)*DIFF_TP-k) + (y2+l)*PSCRX);
  60.       *(tm++) = *(graph_mem + (x2+l) + (y2+(j+2)*DIFF_TP+k)*PSCRX);
  61.       *(tm++) = *(graph_mem + (x2+l) + (y2-(j+2)*DIFF_TP-k)*PSCRX);
  62.     }
  63.     break;
  64.   case 3:
  65.     for(l=-2; l<=2; l++) {
  66.       *(graph_mem + (x1+(j+2)*DIFF_TP+k) + (y1+l)*PSCRX) = *(tm++);
  67.       *(graph_mem + (x1-(j+2)*DIFF_TP-k) + (y1+l)*PSCRX) = *(tm++);
  68.       *(graph_mem + (x1+l) + (y1+(j+2)*DIFF_TP+k)*PSCRX) = *(tm++);
  69.       *(graph_mem + (x1+l) + (y1-(j+2)*DIFF_TP-k)*PSCRX) = *(tm++);
  70.       *(graph_mem + (x2+(j+2)*DIFF_TP+k) + (y2+l)*PSCRX) = *(tm++);
  71.       *(graph_mem + (x2-(j+2)*DIFF_TP-k) + (y2+l)*PSCRX) = *(tm++);
  72.       *(graph_mem + (x2+l) + (y2+(j+2)*DIFF_TP+k)*PSCRX) = *(tm++);
  73.       *(graph_mem + (x2+l) + (y2-(j+2)*DIFF_TP-k)*PSCRX) = *(tm++);
  74.     }
  75.     break;
  76.   }
  77. }
  78.  
  79. void
  80. drawteleport()
  81. {
  82.   int i,j,k;
  83.   int x1,y1,x2,y2;
  84.  
  85.   x1=154+7+shipdx;
  86.   y1= 82+7+shipdy;
  87.   x2=154+7-((252-loadpoint)*sinus2[(alpha+256)&1023])/2016;
  88.   y2= 82+7+((252-loadpoint)*sinus2[alpha])/2016;
  89.  
  90.   vga_waitretrace();
  91.   for(i=0; i<NR_TP+SZ_TP-1; i++) {
  92.     for(k=min(SZ_TP-1,i), j=max(i-(SZ_TP-1),0); j<=min(i,NR_TP-1); k--, j++)
  93.       drawteleline(1, x1, y1, x2, y2, j, k);
  94.     for(k=0; k<3; k++)
  95.       vga_waitretrace();
  96.   }
  97.  
  98.   usleep(250000UL);
  99.   vga_waitretrace();
  100.   putscr(bildx, bildy);
  101.  
  102.   drawteleline(0, 0, 0, 0, 0, 0, 0);
  103.   for(i=0; i<NR_TP+SZ_TP-1; i++)
  104.     for(k=min(SZ_TP-1,i), j=max(i-(SZ_TP-1),0); j<=min(i,NR_TP-1); k--, j++)
  105.       drawteleline(2, x1, y1, x2, y2, j, k);
  106.   drawteleline(0, 0, 0, 0, 0, 0, 0);
  107.   for(i=0; i<NR_TP+SZ_TP-1; i++)
  108.     for(k=min(SZ_TP-1,i), j=max(i-(SZ_TP-1),0); j<=min(i,NR_TP-1); k--, j++)
  109.       drawteleline(1, x1, y1, x2, y2, j, k);
  110.   
  111.   usleep(250000UL);
  112.   
  113.   vga_waitretrace();
  114.   drawteleline(0, 0, 0, 0, 0, 0, 0);
  115.   for(i=0; i<NR_TP+SZ_TP-1; i++) {
  116.     for(k=min(SZ_TP-1,i), j=max(i-(SZ_TP-1),0); j<=min(i,NR_TP-1); k--, j++)
  117.       drawteleline(3, x1, y1, x2, y2, j, k);
  118.     for(k=0; k<3; k++)
  119.       vga_waitretrace();
  120.   }
  121. }
  122.  
  123. void
  124. swap(pa,pb)
  125.      int *pa,*pb;
  126. {
  127.   int    t;
  128.   t=*pa; *pa=*pb; *pb=t;
  129. }
  130.  
  131. void
  132. drawlinev(x1,y1,x2,y2,color,storage)
  133.      int x1,y1,x2,y2;
  134.      byte color;
  135.      byte *storage;
  136. {
  137.   int d,dx,dy;
  138.   int Ai,Bi,xi;
  139.   byte *ptr=bild;
  140.  
  141.   if(y1>y2) {
  142.     swap(&x1,&x2);
  143.     swap(&y1,&y2);
  144.   }
  145.   xi=(x2>x1)?1:-1;
  146.   dx=abs(x2-x1);
  147.   dy=(y2-y1);
  148.   Ai=(dx-dy)<<1;
  149.   Bi=(dx<<1);
  150.   d=Bi-dy;
  151.  
  152.   ptr+=y1*(PBILDX<<1);
  153.   *(storage++)=*(ptr+x1);
  154.   *(ptr+x1)=color;
  155.   for(y1++,ptr+=PBILDX<<1; y1<=y2; y1++,ptr+=PBILDX<<1) {
  156.     if(y1==PBILDY)
  157.       ptr=bild;
  158.     if(d<0)
  159.       d+=Bi;
  160.     else {
  161.       x1+=xi;
  162.       d+=Ai;
  163.     }
  164.     *(storage++)=*(ptr+x1);
  165.     *(ptr+x1)=color;
  166.   }
  167. }
  168.  
  169. void
  170. undrawlinev(x1,y1,x2,y2,storage)
  171.      int x1,y1,x2,y2;
  172.      byte *storage;
  173. {
  174.   int d,dx,dy;
  175.   int Ai,Bi,xi;
  176.   byte *ptr=bild;
  177.  
  178.   if(y1>y2) {
  179.     swap(&x1,&x2);
  180.     swap(&y1,&y2);
  181.   }
  182.   xi=(x2>x1)?1:-1;
  183.   dx=abs(x2-x1);
  184.   dy=(y2-y1);
  185.   Ai=(dx-dy)<<1;
  186.   Bi=(dx<<1);
  187.   d=Bi-dy;
  188.  
  189.   ptr+=y1*(PBILDX<<1);
  190.   *(ptr+x1)=*(storage++);
  191.   for(y1++,ptr+=PBILDX<<1; y1<=y2; y1++,ptr+=PBILDX<<1) {
  192.     if(y1==PBILDY)
  193.       ptr=bild;
  194.     if(d<0)
  195.       d+=Bi;
  196.     else {
  197.       x1+=xi;
  198.       d+=Ai;
  199.     }
  200.     *(ptr+x1)=*(storage++);
  201.   }
  202. }
  203.  
  204. void
  205. drawlineh(x1,y1,x2,y2,color,storage)
  206.      int x1,y1,x2,y2;
  207.      byte color;
  208.      byte *storage;
  209. {
  210.   int d,dx,dy;
  211.   int Ai,Bi,yi,i;
  212.   byte *ptr=bild;
  213.  
  214.   if(x1>x2) {
  215.     swap(&x1,&x2);
  216.     swap(&y1,&y2);
  217.   }
  218.   if(y2>y1) {
  219.     yi=PBILDX<<1;
  220.     i=1;
  221.   }
  222.   else {
  223.     yi=-PBILDX<<1;
  224.     i=-1;
  225.   }
  226.   dx=x2-x1;
  227.   dy=abs(y2-y1);
  228.   Ai=(dy-dx)<<1;
  229.   Bi=(dy<<1);
  230.   d=Bi-dx;
  231.   if(y1>PBILDY)
  232.     y1-=PBILDY;
  233.   y2=y1;
  234.   y1=y1*PBILDX<<1;
  235.  
  236.   ptr+=y1;
  237.   *(storage++)=*(ptr+x1);
  238.   *(ptr+x1)=color;
  239.   for(x1++; x1<=x2; x1++) {
  240.     if(d<0)
  241.       d+=Bi;
  242.     else {
  243.       ptr+=yi;
  244.       y2+=i;
  245.       if(y2==-1)
  246.     ptr+=PBILDY*PBILDX<<1;
  247.       if(y2==PBILDY)
  248.     ptr=bild;
  249.       d+=Ai;
  250.     }
  251.     *(storage++)=*(ptr+x1);
  252.     *(ptr+x1)=color;
  253.   }
  254. }
  255.  
  256. void
  257. undrawlineh(x1,y1,x2,y2,storage)
  258.      int x1,y1,x2,y2;
  259.      byte *storage;
  260. {
  261.   int d,dx,dy;
  262.   int Ai,Bi,yi,i;
  263.   byte *ptr=bild;
  264.  
  265.   if(x1>x2) {
  266.     swap(&x1,&x2);
  267.     swap(&y1,&y2);
  268.   }
  269.   if(y2>y1) {
  270.     yi=PBILDX<<1;
  271.     i=1;
  272.   }
  273.   else {
  274.     yi=-PBILDX<<1;
  275.     i=-1;
  276.   }
  277.   dx=x2-x1;
  278.   dy=abs(y2-y1);
  279.   Ai=(dy-dx)<<1;
  280.   Bi=(dy<<1);
  281.   d=Bi-dx;
  282.   if(y1>PBILDY)
  283.     y1-=PBILDY;
  284.   y2=y1;
  285.   y1=y1*PBILDX<<1;
  286.  
  287.   ptr+=y1;
  288.   *(ptr+x1)=*(storage++);
  289.   for(x1++; x1<=x2; x1++) {
  290.     if(d<0)
  291.       d+=Bi;
  292.     else {
  293.       ptr+=yi;
  294.       y2+=i;
  295.       if(y2==-1)
  296.     ptr+=PBILDY*PBILDX<<1;
  297.       if(y2==PBILDY)
  298.     ptr=bild;
  299.       d+=Ai;
  300.     }
  301.     *(ptr+x1)=*(storage++);
  302.   }
  303. }
  304.  
  305. void
  306. drawline(x1,y1,x2,y2,color,storage)
  307.      int x1,y1,x2,y2;
  308.      byte color;
  309.      byte *storage;
  310. {
  311.   if(y1>y2+64)
  312.     y2+=PBILDY;
  313.   if(y2>y1+64)
  314.     y1+=PBILDY;
  315.   if(abs(x1-x2)<abs(y1-y2))
  316.     drawlinev(x1,y1,x2,y2,color,storage);
  317.   else
  318.     drawlineh(x1,y1,x2,y2,color,storage);
  319. }
  320.  
  321. void
  322. undrawline(x1,y1,x2,y2,storage)
  323.      int x1,y1,x2,y2;
  324.      byte *storage;
  325. {
  326.   if(y1>y2+64)
  327.     y2+=PBILDY;
  328.   if(y2>y1+64)
  329.     y1+=PBILDY;
  330.   if(abs(x1-x2)<abs(y1-y2))
  331.     undrawlinev(x1,y1,x2,y2,storage);
  332.   else
  333.     undrawlineh(x1,y1,x2,y2,storage);
  334. }
  335.  
  336. void
  337. drawbullets()
  338. {
  339.   int l;
  340.   bullet *bulletptr;
  341.   word tempx,tempy;
  342.  
  343.   for(l=0, bulletptr=bullets; l<maxbullets; l++, bulletptr++)
  344.     if((*bulletptr).life) {
  345.       tempx=(*bulletptr).x>>3;
  346.       tempy=(*bulletptr).y>>3;
  347.       if(pixx+PSCRX>lenx3 && tempx<PSCRX)
  348.     tempx+=lenx3;
  349.       if(pixy+PSCRY>leny3 && tempy<PSCRY)
  350.     tempy+=leny3;
  351.       if(insidepixel(tempx, tempy, pixx, pixy, 4, 4))
  352.     drawsquare(bildx+tempx-pixx, tempy%PBILDY,
  353.            bulletmap+((*bulletptr).dir<<4),
  354.            bulletstorage+(l<<4), 4, 4);
  355.       else if(*(bana+(tempx>>3)%lenx+((tempy>>3)%leny)*lenx)!=32)
  356.     (*bulletptr).life=0;
  357.     }
  358. }
  359.  
  360. void
  361. undrawbullets()
  362. {
  363.   int l;
  364.   bullet *bulletptr;
  365.   word tempx,tempy;
  366.   word crash;
  367.  
  368.   for(l=maxbullets-1, bulletptr=bullets+maxbullets-1; l>=0; l--, bulletptr--)
  369.     if((*bulletptr).life) {
  370.       tempx=(*bulletptr).x>>3;
  371.       tempy=(*bulletptr).y>>3;
  372.       if(pixx+PSCRX>lenx3 && tempx<PSCRX)
  373.     tempx+=lenx3;
  374.       if(pixy+PSCRY>leny3 && tempy<PSCRY)
  375.     tempy+=leny3;
  376.       if(insidepixel(tempx, tempy, pixx, pixy, 4, 4)) {
  377.     crash=testcrash(bulletmap+((*bulletptr).dir<<4),
  378.             bulletstorage+(l<<4), 16, 0);
  379.     if(crash) {
  380.       if(crash>=4)
  381.         hit((tempx+3)%lenx3,(tempy+3)%leny3,crash,(*bulletptr).owner);
  382.       (*bulletptr).life=0;
  383.     }
  384.     undrawsquare(bildx+tempx-pixx, tempy%PBILDY,
  385.              bulletstorage+(l<<4), 4, 4);
  386.       }
  387.     }
  388. }
  389.  
  390. void
  391. drawfragments()
  392. {
  393.   int l;
  394.   fragment *fragmentptr;
  395.   word tempx,tempy;
  396.   static byte fragmentmap[4]={ 12,12,12,12 };
  397.  
  398.   for(l=0, fragmentptr=fragments; l<maxfragments; l++, fragmentptr++)
  399.     if((*fragmentptr).life) {
  400.       tempx=(*fragmentptr).x>>3;
  401.       tempy=(*fragmentptr).y>>3;
  402.       if(pixx+PSCRX>lenx3 && tempx<PSCRX)
  403.     tempx+=lenx3;
  404.       if(pixy+PSCRY>leny3 && tempy<PSCRY)
  405.     tempy+=leny3;
  406.       if(insidepixel(tempx, tempy, pixx, pixy, 2, 2))
  407.     drawsquare(bildx+tempx-pixx, tempy%PBILDY,
  408.            fragmentmap, fragmentstorage+(l<<2), 2, 2);
  409.       else if(*(bana+(tempx>>3)%lenx+((tempy>>3)%leny)*lenx)!=32)
  410.     (*fragmentptr).life=0;
  411.     }
  412. }
  413.  
  414. void
  415. undrawfragments()
  416. {
  417.   int l;
  418.   fragment *fragmentptr;
  419.   word tempx,tempy;
  420.   word crash;
  421.   static byte fragmentmap[4]={ 12,12,12,12 };
  422.  
  423.   for(l=maxfragments-1, fragmentptr=fragments+maxfragments-1;
  424.       l>=0;
  425.       l--, fragmentptr--)
  426.     if((*fragmentptr).life) {
  427.       tempx=(*fragmentptr).x>>3;
  428.       tempy=(*fragmentptr).y>>3;
  429.       if(pixx+PSCRX>lenx3 && tempx<PSCRX)
  430.     tempx+=lenx3;
  431.       if(pixy+PSCRY>leny3 && tempy<PSCRY)
  432.     tempy+=leny3;
  433.       if(insidepixel(tempx, tempy, pixx, pixy, 2, 2)) {
  434.     crash=testcrash(fragmentmap, fragmentstorage+(l<<2), 4, 0);
  435.     if(crash) {
  436. /*      if(crash>=4)
  437.         hit((tempx+3)%lenx3,(tempy+3)%leny3,crash); */
  438.       (*fragmentptr).life=0;
  439.     }
  440.     undrawsquare(bildx+tempx-pixx, tempy%PBILDY,
  441.              fragmentstorage+(l<<2), 2, 2);
  442.       }
  443.     }
  444. }
  445.  
  446. void
  447. drawspacestationblip()
  448. {
  449.   word tempx,tempy;
  450.  
  451.   tempx=ssx;
  452.   tempy=ssy;
  453.   if(pblockx+BBILDX>lenx && tempx<BBILDX)
  454.     tempx+=lenx;
  455.   if(pblocky+BBILDY>leny && tempy<BBILDY)
  456.     tempy+=leny;
  457.   if(insideblock(tempx,tempy,pblockx,pblocky,0,0))
  458.     putblock(bblockx-pblockx+tempx, tempy%BBILDY,
  459.          blocks+((ssblip?32:222-(scount&0xc))<<6));
  460. }
  461.  
  462. void
  463. drawload(flag)
  464.      int flag;
  465. {
  466.   word tempx,tempy;
  467.  
  468.   tempx=loadbx;
  469.   tempy=loadby;
  470.   if(pblockx+BBILDX>lenx && tempx<BBILDX)
  471.     tempx+=lenx;
  472.   if(pblocky+BBILDY>leny && tempy<BBILDY)
  473.     tempy+=leny;
  474.   putblock(bblockx-pblockx+tempx, tempy%BBILDY,
  475.        blocks+((flag?253:32)<<6));
  476. }
  477.  
  478. word
  479. drawshuttle()
  480. {
  481.   word crash=0,tmp;
  482.   int x1,x2=0,y1,y2=0,lx,ly;
  483.   static byte wiremap[64]={
  484.     13,13,13,13,13,13,13,13,
  485.     13,13,13,13,13,13,13,13,
  486.     13,13,13,13,13,13,13,13,
  487.     13,13,13,13,13,13,13,13,
  488.     13,13,13,13,13,13,13,13,
  489.     13,13,13,13,13,13,13,13,
  490.     13,13,13,13,13,13,13,13,
  491.     13,13,13,13,13,13,13,13};
  492.  
  493.   if(loaded || loadcontact) {
  494.     x1=bildx+161+shipdx;
  495.     y1=(bildy+89+shipdy);
  496.     if(loaded) {
  497.       x2=bildx+161-((252-loadpoint)*sinus2[(alpha+256)&1023])/2016;
  498.       y2=bildy+ 89+((252-loadpoint)*sinus2[alpha])/2016;
  499.     }
  500.     else {
  501.       x2=(loadbx<<3)+3;
  502.       if(abs(x2-x1)>PBILDX/2)
  503.     x2+=PBILDX;
  504.       y2=(loadby<<3)+3;
  505.     }
  506.     lx=abs(x1-x2)%PBILDX;
  507.     ly=abs(y1-y2)%PBILDY;
  508.     if(lx>64)
  509.       lx=abs(lx-PBILDX);
  510.     if(ly>64)
  511.       ly=abs(ly-PBILDY);
  512.     drawline(x1, y1%PBILDY, x2, y2%PBILDY, 13, wirestorage);
  513.     tmp=testcrash(wiremap, wirestorage, max(lx,ly)+1, shield);
  514.     crash=max(crash, tmp);
  515.   }
  516.   /* Draw the shuttle */
  517.   drawship(bildx+154+shipdx, (bildy+82+shipdy)%PBILDY,
  518.        (shield?shieldship:ship)+(dir<<8), shipstorage);
  519.   tmp=testcrash(ship+(dir<<8), shipstorage, 256, shield);
  520.   crash=max(tmp,crash);
  521.   if(loaded || loadcontact) {
  522.     if(loaded)
  523.       drawsquare(x2-3, (y2-3)%PBILDY, loadmap, loadstorage, 8, 8);
  524.     else if(loadcontact) {
  525.       x1=loadbx<<3;
  526.       y1=loadby<<3;
  527.       if(pixx+PBILDX>lenx3 && x1<PBILDX)
  528.     x1+=lenx3;
  529.       if(pixy+PBILDY>leny3 && y1<PBILDY)
  530.     y1+=leny3;
  531.       drawsquare(bildx-pixx+x1, y1%PBILDY, loadmap, loadstorage, 8, 8);
  532.     }
  533.     tmp=testcrash(loadmap, loadstorage, 64, shield);
  534.     crash=max(crash, tmp);
  535.   }
  536.   return(crash);
  537. }
  538.  
  539. void
  540. undrawshuttle()
  541. {
  542.   int x1,x2=0,y1,y2=0;
  543.  
  544.   if(loaded || loadcontact)
  545.     if(loaded) {
  546.       x2=bildx+161-((252-loadpoint)*sinus2[(alpha+256)&1023])/2016;
  547.       y2=bildy+ 89+((252-loadpoint)*sinus2[alpha])/2016;
  548.       undrawsquare(x2-3,(y2-3)%PBILDY,loadstorage,8,8);
  549.     }
  550.     else if(loadcontact) {
  551.       x1=loadbx<<3;
  552.       y1=loadby<<3;
  553.       if(pixx+PBILDX>lenx3 && x1<PBILDX)
  554.     x1+=lenx3;
  555.       if(pixy+PBILDY>leny3 && y1<PBILDY)
  556.     y1+=leny3;
  557.       undrawsquare(bildx-pixx+x1,y1%PBILDY,loadstorage,8,8);
  558.     }
  559.   undrawship(bildx+154+shipdx,(bildy+82+shipdy)%PBILDY,
  560.          shipstorage);
  561.   if(loaded || loadcontact) {
  562.     x1=bildx+161+shipdx;
  563.     y1=(bildy+89+shipdy);
  564.     if(loadcontact) {
  565.       x2=(loadbx<<3)+3;
  566.       if(abs(x2-x1)>PBILDX/2)
  567.     x2+=PBILDX;
  568.       y2=(loadby<<3)+3;
  569.     }
  570.     undrawline(x1,y1%PBILDY,x2,y2%PBILDY,wirestorage);
  571.   }
  572. }
  573.  
  574. void
  575. drawfuellines()
  576. {
  577.   drawsquare(bildx+shipdx+151,(bildy+shipdy+98)%PBILDY,
  578.          fuelmap,fuelstorage,4,32);
  579.   drawsquare(bildx+shipdx+168,(bildy+shipdy+98)%PBILDY,
  580.          fuelmap+128,fuelstorage+128,4,32);
  581. }
  582.  
  583. void
  584. undrawfuellines()
  585. {
  586.   undrawsquare(bildx+shipdx+151,(bildy+shipdy+98)%PBILDY,
  587.            fuelstorage,4,32);
  588.   undrawsquare(bildx+shipdx+168,(bildy+shipdy+98)%PBILDY,
  589.            fuelstorage+128,4,32);
  590. }
  591.